
use crate::metadata::ir::*;
pub(crate) static REGISTERS: IR = IR {
    blocks: &[Block {
        name: "Tamp",
        extends: None,
        description: Some("Tamper and backup registers"),
        items: &[
            BlockItem {
                name: "cr1",
                description: Some("control register 1"),
                array: None,
                byte_offset: 0x0,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Cr1"),
                }),
            },
            BlockItem {
                name: "cr2",
                description: Some("control register 2"),
                array: None,
                byte_offset: 0x4,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Cr2"),
                }),
            },
            BlockItem {
                name: "cr3",
                description: Some("control register 3"),
                array: None,
                byte_offset: 0x8,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Cr3"),
                }),
            },
            BlockItem {
                name: "fltcr",
                description: Some("TAMP filter control register"),
                array: None,
                byte_offset: 0xc,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Fltcr"),
                }),
            },
            BlockItem {
                name: "atcr1",
                description: Some("TAMP active tamper control register 1"),
                array: None,
                byte_offset: 0x10,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Atcr1"),
                }),
            },
            BlockItem {
                name: "atseedr",
                description: Some("TAMP active tamper seed register"),
                array: None,
                byte_offset: 0x14,
                inner: BlockItemInner::Register(Register {
                    access: Access::Write,
                    bit_size: 32,
                    fieldset: Some("Atseedr"),
                }),
            },
            BlockItem {
                name: "ator",
                description: Some("TAMP active tamper output register"),
                array: None,
                byte_offset: 0x18,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: Some("Ator"),
                }),
            },
            BlockItem {
                name: "atcr2",
                description: Some("TAMP active tamper control register 2"),
                array: None,
                byte_offset: 0x1c,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Atcr2"),
                }),
            },
            BlockItem {
                name: "smcr",
                description: Some("TAMP secure mode register"),
                array: None,
                byte_offset: 0x20,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Smcr"),
                }),
            },
            BlockItem {
                name: "privcr",
                description: Some("TAMP privilege mode control register"),
                array: None,
                byte_offset: 0x24,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Privcr"),
                }),
            },
            BlockItem {
                name: "ier",
                description: Some("TAMP interrupt enable register"),
                array: None,
                byte_offset: 0x2c,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Ier"),
                }),
            },
            BlockItem {
                name: "sr",
                description: Some("TAMP status register"),
                array: None,
                byte_offset: 0x30,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: Some("Sr"),
                }),
            },
            BlockItem {
                name: "misr",
                description: Some("TAMP masked interrupt status register"),
                array: None,
                byte_offset: 0x34,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: Some("Misr"),
                }),
            },
            BlockItem {
                name: "smisr",
                description: Some("TAMP secure masked interrupt status register"),
                array: None,
                byte_offset: 0x38,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: Some("Smisr"),
                }),
            },
            BlockItem {
                name: "scr",
                description: Some("TAMP status clear register"),
                array: None,
                byte_offset: 0x3c,
                inner: BlockItemInner::Register(Register {
                    access: Access::Write,
                    bit_size: 32,
                    fieldset: Some("Scr"),
                }),
            },
            BlockItem {
                name: "countr",
                description: Some("TAMP monotonic counter register"),
                array: None,
                byte_offset: 0x40,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: Some("Countr"),
                }),
            },
            BlockItem {
                name: "cfgr",
                description: Some("TAMP configuration register"),
                array: None,
                byte_offset: 0x50,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Cfgr"),
                }),
            },
            BlockItem {
                name: "bkpr",
                description: Some("TAMP backup register"),
                array: Some(Array::Regular(RegularArray { len: 32, stride: 4 })),
                byte_offset: 0x100,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Bkpr"),
                }),
            },
        ],
    }],
    fieldsets: &[
        FieldSet {
            name: "Atcr1",
            extends: None,
            description: Some("TAMP active tamper control register 1"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "tampam",
                    description: Some("TAMPAM"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                    enumm: None,
                },
                Field {
                    name: "atosel",
                    description: Some("ATOSEL"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 8 }),
                    bit_size: 2,
                    array: Some(Array::Regular(RegularArray { len: 4, stride: 2 })),
                    enumm: None,
                },
                Field {
                    name: "atcksel",
                    description: Some("ATCKSEL"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 2,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "atper",
                    description: Some("ATPER"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 24 }),
                    bit_size: 2,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "atoshare",
                    description: Some("ATOSHARE"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 30 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "flten",
                    description: Some("FLTEN"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 31 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Atcr2",
            extends: None,
            description: Some("TAMP active tamper control register 2"),
            bit_size: 32,
            fields: &[Field {
                name: "atosel",
                description: Some("ATOSEL"),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 8 }),
                bit_size: 3,
                array: Some(Array::Regular(RegularArray { len: 8, stride: 3 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Ator",
            extends: None,
            description: Some("TAMP active tamper output register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "prng",
                    description: Some("Pseudo-random generator value"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 8,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "seedf",
                    description: Some("Seed running flag"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 14 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "inits",
                    description: Some("Active tamper initialization status"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 15 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Atseedr",
            extends: None,
            description: Some("TAMP active tamper seed register"),
            bit_size: 32,
            fields: &[Field {
                name: "seed",
                description: Some("Pseudo-random generator seed value"),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 32,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Bkpr",
            extends: None,
            description: Some("TAMP backup register"),
            bit_size: 32,
            fields: &[Field {
                name: "bkp",
                description: Some("BKP"),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 32,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Cfgr",
            extends: None,
            description: Some("TAMP configuration register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "tmonen",
                    description: Some("TMONEN"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "vmonen",
                    description: Some("VMONEN"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "wutmonen",
                    description: Some("WUTMONEN"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 3 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Countr",
            extends: None,
            description: Some("TAMP monotonic counter register"),
            bit_size: 32,
            fields: &[Field {
                name: "count",
                description: Some("COUNT"),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 32,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Cr1",
            extends: None,
            description: Some("control register 1"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "tampe",
                    description: Some("TAMPE"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                    enumm: None,
                },
                Field {
                    name: "itampe",
                    description: Some("ITAMPE"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Cr2",
            extends: None,
            description: Some("control register 2"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "tampnoer",
                    description: Some("Tamper X no erase"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                    enumm: None,
                },
                Field {
                    name: "tampmsk",
                    description: Some("Tamper X mask"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 3, stride: 1 })),
                    enumm: None,
                },
                Field {
                    name: "bkerase",
                    description: Some("BKERASE"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 23 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "tamptrg",
                    description: Some("Active level for tamper X input"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 24 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Cr3",
            extends: None,
            description: Some("control register 3"),
            bit_size: 32,
            fields: &[Field {
                name: "itampnoer",
                description: Some("Internal Tamper X no erase"),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 1,
                array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Fltcr",
            extends: None,
            description: Some("TAMP filter control register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "tampfreq",
                    description: Some("TAMPFREQ"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 3,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "tampflt",
                    description: Some("TAMPFLT"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 3 }),
                    bit_size: 2,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "tampprch",
                    description: Some("TAMPPRCH"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 5 }),
                    bit_size: 2,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "tamppudis",
                    description: Some("TAMPPUDIS"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 7 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Ier",
            extends: None,
            description: Some("TAMP interrupt enable register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "tampie",
                    description: Some("Tamper X interrupt enable"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                    enumm: None,
                },
                Field {
                    name: "itampie",
                    description: Some("Internal tamper X interrupt enable"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Misr",
            extends: None,
            description: Some("TAMP masked interrupt status register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "tampmf",
                    description: Some("Tamper X interrupt masked flag"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                    enumm: None,
                },
                Field {
                    name: "itampmf",
                    description: Some("Internal tamper X interrupt masked flag"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Privcr",
            extends: None,
            description: Some("TAMP privilege mode control register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "bkprwpriv",
                    description: Some("Backup registers zone 1 privilege protection"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 29 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "bkpwpriv",
                    description: Some("Backup registers zone 2 privilege protection"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 30 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "tamppriv",
                    description: Some("Tamper privilege protection"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 31 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Scr",
            extends: None,
            description: Some("TAMP status clear register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "ctampf",
                    description: Some("Clear tamper X detection flag"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                    enumm: None,
                },
                Field {
                    name: "citampf",
                    description: Some("Clear internal tamper X detection flag"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Smcr",
            extends: None,
            description: Some("TAMP secure mode register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "bkprwdprot",
                    description: Some("Backup registers read/write protection offset"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 8,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "bkpwdprot",
                    description: Some("Backup registers write protection offset"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 8,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "tampdprot",
                    description: Some("Tamper protection"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 31 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Smisr",
            extends: None,
            description: Some("TAMP secure masked interrupt status register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "tampmf",
                    description: Some("Tamper X interrupt masked flag"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                    enumm: None,
                },
                Field {
                    name: "itampmf",
                    description: Some("Internal tamper X interrupt masked flag"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Sr",
            extends: None,
            description: Some("TAMP status register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "tampf",
                    description: Some("Tamper X detection flag"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                    enumm: None,
                },
                Field {
                    name: "itampf",
                    description: Some("Internal tamper X detection flag"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 8, stride: 1 })),
                    enumm: None,
                },
            ],
        },
    ],
    enums: &[],
};
